Nanodegree key: nd013
Version: 2.0.0
Locale: en-us
Work on the future of autonomous vehicles and help make the self-driving car revolution a reality!
Content
Part 01 : Computer Vision, Deep Learning, and Sensor Fusion
In this term, you'll first become an expert in applying Computer Vision and Deep Learning on automotive problems. You will teach the car to detect lane lines, predict steering angle, and more all based on just camera data!
Next, you'll learn Sensor Fusion, or how to use an array of sensor data to perceive the environment around the vehicle.
-
Module 01: Introduction
-
Lesson 01: Introduction
Welcome! Get an introduction to the program, discover the services we provide, and get a sneak-peek at the incredible projects you'll build.
- Concept 01: Why Self-Driving Cars?
- Concept 02: Meet Your Instructors
- Concept 03: Overview of ND Program
- Concept 04: What Projects Will You Build?
- Concept 05: Access the Career Portal
- Concept 06: Prepare for the Udacity Talent Program
- Concept 07: Community Code of Conduct
- Concept 08: Rating Your Career Confidence
- Concept 09: Self-Driving Car History
- Concept 10: The Great Robot Race (Optional)
- Concept 11: Self-Driving Car Quiz
- Concept 12: C++ Readiness
-
Lesson 02: Welcome to Udacity
You are starting a challenging but rewarding journey! Take 5 minutes to read how to get help with projects and content.
-
Lesson 03: Get Help with Your Account
What to do if you have questions about your account or general questions about the program.
-
-
Module 02: Computer Vision
-
Lesson 01: Computer Vision Fundamentals
Get a taste of some basic computer vision techniques to find lane markings on the road.
- Concept 01: Power of Cameras
- Concept 02: Setting up the Problem
- Concept 03: Color Selection
- Concept 04: Color Selection Code Example
- Concept 05: Color Selection
- Concept 06: Region Masking
- Concept 07: Color and Region Combined
- Concept 08: Color Region
- Concept 09: Finding Lines of Any Color
- Concept 10: What is Computer Vision?
- Concept 11: Canny Edge Detection
- Concept 12: Canny to Detect Lane Lines
- Concept 13: Canny Edges
- Concept 14: Hough Transform
- Concept 15: Hough Transform to Find Lane Lines
- Concept 16: Hough Transform
- Concept 17: Parameter Tuning
-
Lesson 02: Project: Finding Lane Lines
Write code to identify lane lines on the road, first in an image, and later in a video stream.
-
Lesson 03: Camera Calibration
Learn how to calibrate your camera to remove inherent distortions that can affect its perception of the world.
- Concept 01: The Challenges with Cameras
- Concept 02: Welcome to Computer Vision
- Concept 03: Overview
- Concept 04: Getting Started
- Concept 05: Distortion Correction
- Concept 06: Effects of Distortion
- Concept 07: Pinhole Camera Model
- Concept 08: Image Formation
- Concept 09: Measuring Distortion
- Concept 10: Finding Corners
- Concept 11: Calibrating Your Camera
- Concept 12: Correcting for Distortion
- Concept 13: Lane Curvature
- Concept 14: Perspective Transform
- Concept 15: Curvature and Perspective
- Concept 16: Transform a Stop Sign
- Concept 17: Intuitions
- Concept 18: Undistort and Transform
- Concept 19: How I Did It
- Concept 20: Coming Up
-
Lesson 04: Gradients and Color Spaces
Learn how to use gradient thresholds and different color spaces to more easily identify lane markings on the road.
- Concept 01: Gradient Threshold
- Concept 02: Sobel Operator
- Concept 03: Applying Sobel
- Concept 04: Magnitude of the Gradient
- Concept 05: Direction of the Gradient
- Concept 06: Combining Thresholds
- Concept 07: Color Spaces
- Concept 08: Color Thresholding
- Concept 09: HLS intuitions
- Concept 10: HLS and Color Thresholds
- Concept 11: HLS Quiz
- Concept 12: Color and Gradient
-
Lesson 05: Advanced Computer Vision
Discover more advanced computer vision techniques to improve upon your lane lines algorithm!
- Concept 01: Reviewing Steps
- Concept 02: Processing Each Image
- Concept 03: Finding the Lines: Histogram Peaks
- Concept 04: Finding the Lines: Sliding Window
- Concept 05: Finding the Lines: Search from Prior
- Concept 06: Measuring Curvature I
- Concept 07: Measuring Curvature II
- Concept 08: Bonus Round: Computer Vision [Optional]
-
Lesson 06: Project: Advanced Lane Finding
Write a software pipeline to identify the lane boundaries in a video from a front-facing camera on a car.
-
-
Module 03: Deep Learning
-
Lesson 01: Neural Networks
Build and train neural networks from linear and logistic regression to backpropagation and multilayer perceptron networks.
- Concept 01: Neural Network Intuition
- Concept 02: Introduction to Deep Learning
- Concept 03: Starting Machine Learning
- Concept 04: A Note on Deep Learning
- Concept 05: Quiz: Housing Prices
- Concept 06: Solution: Housing Prices
- Concept 07: Linear to Logistic Regression
- Concept 08: Classification Problems 1
- Concept 09: Classification Problems 2
- Concept 10: Linear Boundaries
- Concept 11: Higher Dimensions
- Concept 12: Perceptrons
- Concept 13: Perceptrons II
- Concept 14: Why "Neural Networks"?
- Concept 15: Perceptrons as Logical Operators
- Concept 16: Perceptron Trick
- Concept 17: Perceptron Algorithm
- Concept 18: Error Functions
- Concept 19: Log-loss Error Function
- Concept 20: Discrete vs Continuous
- Concept 21: Softmax
- Concept 22: One-Hot Encoding
- Concept 23: Maximum Likelihood
- Concept 24: Maximizing Probabilities
- Concept 25: Cross-Entropy 1
- Concept 26: Cross-Entropy 2
- Concept 27: Multi-Class Cross Entropy
- Concept 28: Logistic Regression
- Concept 29: Gradient Descent
- Concept 30: Gradient Descent: The Code
- Concept 31: Perceptron vs Gradient Descent
- Concept 32: Continuous Perceptrons
- Concept 33: Non-linear Data
- Concept 34: Non-Linear Models
- Concept 35: Neural Network Architecture
- Concept 36: Feedforward
- Concept 37: Multilayer Perceptrons
- Concept 38: Backpropagation
- Concept 39: Further Reading
-
Lesson 02: TensorFlow
The Principal Scientist at Google Brain introduces you to deep learning and Tensorflow, Google's deep learning framework.
- Concept 01: Deep Learning Frameworks
- Concept 02: Introduction to Deep Neural Networks
- Concept 03: What is Deep Learning?
- Concept 04: Solving Problems - Big and Small
- Concept 05: Let's Get Started!
- Concept 06: Installing TensorFlow
- Concept 07: Hello, Tensor World!
- Concept 08: Quiz: Tensorflow Input
- Concept 09: Quiz: Tensorflow Math
- Concept 10: Transition to Classification
- Concept 11: Supervised Classification
- Concept 12: Let's make a deal
- Concept 13: Training Your Logistic Classifier
- Concept 14: TensorFlow Linear Function
- Concept 15: Quiz: Linear Function
- Concept 16: Linear Update
- Concept 17: Quiz: Softmax
- Concept 18: Quiz: TensorFlow Softmax Workspaces
- Concept 19: One-Hot Encoding
- Concept 20: Quiz: One-Hot Encoding
- Concept 21: Cross Entropy
- Concept 22: Minimizing Cross Entropy
- Concept 23: Practical Aspects of Learning
- Concept 24: Quiz: Numerical Stability
- Concept 25: Normalized Inputs and Initial Weights
- Concept 26: Measuring Performance
- Concept 27: Transition: Overfitting -> Dataset Size
- Concept 28: Validation and Test Set Size
- Concept 29: Validation Set Size
- Concept 30: Validation Test Set Size Continued
- Concept 31: Optimizing a Logistic Classifier
- Concept 32: Stochastic Gradient Descent
- Concept 33: Momentum and Learning Rate Decay
- Concept 34: Parameter Hyperspace!
- Concept 35: Mini-batch
- Concept 36: Quiz 2: Mini-batch
- Concept 37: Epochs
- Concept 38: Intro TensorFlow Neural Network
- Concept 39: Lab: Neural Network Workspaces
-
Lesson 03: Deep Neural Networks
Learn how to go from a simple neural network to a deep neural network.
- Concept 01: Let's Go Deeper
- Concept 02: Intro to Deep Neural Networks
- Concept 03: Number of Parameters
- Concept 04: Linear Models are Limited
- Concept 05: Rectified Linear Units
- Concept 06: Network of ReLUs
- Concept 07: 2-Layer Neural Network
- Concept 08: Quiz: TensorFlow ReLu
- Concept 09: No Neurons
- Concept 10: The Chain Rule
- Concept 11: Backprop
- Concept 12: Deep Neural Network in TensorFlow
- Concept 13: Training a Deep Learning Network
- Concept 14: Save and Restore TensorFlow Models
- Concept 15: Finetuning
- Concept 16: Regularization Intro
- Concept 17: Regularization
- Concept 18: Regularization Quiz
- Concept 19: Dropout
- Concept 20: Dropout Pt. 2
- Concept 21: Quiz: TensorFlow Dropout
- Concept 22: Quiz 2: TensorFlow Dropout
-
Lesson 04: Convolutional Neural Networks
Learn the theory behind Convolutional Neural Networks and how they help us dramatically improve performance in image classification.
- Concept 01: CNNs Have Taken Over
- Concept 02: Intro To CNNs
- Concept 03: Color
- Concept 04: Statistical Invariance
- Concept 05: Convolutional Networks
- Concept 06: Intuition
- Concept 07: Filters
- Concept 08: Feature Map Sizes
- Concept 09: Convolutions continued
- Concept 10: Parameters
- Concept 11: Quiz: Convolution Output Shape
- Concept 12: Solution: Convolution Output Shape
- Concept 13: Quiz: Number of Parameters
- Concept 14: Solution: Number of Parameters
- Concept 15: Quiz: Parameter Sharing
- Concept 16: Solution: Parameter Sharing
- Concept 17: Visualizing CNNs
- Concept 18: TensorFlow Convolution Layer
- Concept 19: Explore The Design Space
- Concept 20: TensorFlow Max Pooling
- Concept 21: Quiz: Pooling Intuition
- Concept 22: Solution: Pooling Intuition
- Concept 23: Quiz: Pooling Mechanics
- Concept 24: Solution: Pooling Mechanics
- Concept 25: Quiz: Pooling Practice
- Concept 26: Solution: Pooling Practice
- Concept 27: Quiz: Average Pooling
- Concept 28: Solution: Average Pooling
- Concept 29: 1x1 Convolutions
- Concept 30: Inception Module
- Concept 31: Convolutional Network in TensorFlow
- Concept 32: TensorFlow Convolutional Layer Workspaces
- Concept 33: Solution: TensorFlow Convolution Layer
- Concept 34: TensorFlow Pooling Layer Workspaces
- Concept 35: Solution: TensorFlow Pooling Layer
- Concept 36: Lab: LeNet in TensorFlow
- Concept 37: LeNet Lab Workspace
- Concept 38: CNNs - Additional Resources
-
Lesson 05: LeNet for Traffic Signs
Using the infamous LeNet neural network architecture, take your first steps toward building a Traffic Sign classifier!
- Concept 01: Introduction
- Concept 02: LeNet Architecture
- Concept 03: LeNet Data
- Concept 04: LeNet Implementation
- Concept 05: LeNet Training Pipeline
- Concept 06: LeNet Evaluation Pipeline
- Concept 07: LeNet Training the Model
- Concept 08: LeNet Testing
- Concept 09: LeNet for Traffic Signs
- Concept 10: Visualizing Layers
-
Lesson 06: Project: Traffic Sign Classifier
Put your skills to the test by using deep learning to classify different traffic signs!
-
Lesson 07: Keras
Take on the neural network framework, Keras! Build and train neural networks more easily.
- Concept 01: Deep Learning Breakthroughs
- Concept 02: Introduction
- Concept 03: Deep Learning Frameworks
- Concept 04: High Level Frameworks
- Concept 05: Keras Overview
- Concept 06: Neural Networks in Keras
- Concept 07: Convolutions in Keras
- Concept 08: Pooling in Keras
- Concept 09: Dropout in Keras
- Concept 10: Testing in Keras
- Concept 11: Conclusion
-
Lesson 08: Transfer Learning
Learn about some of the most famous neural network architectures, and how you can use them to create new models by leveraging existing canonical networks.
- Concept 01: Introduction
- Concept 02: Bryan Catanzaro
- Concept 03: GPU vs. CPU
- Concept 04: Transfer Learning
- Concept 05: Deep Learning History
- Concept 06: ImageNet
- Concept 07: AlexNet
- Concept 08: AlexNet Today
- Concept 09: VGG
- Concept 10: Empirics
- Concept 11: GoogLeNet
- Concept 12: ResNet
- Concept 13: Without Pre-trained Weights
- Concept 14: Lab: Transfer Learning
- Concept 15: Outro
- Concept 16: Bonus Round: Deep Learning [Optional]
-
Lesson 09: Project: Behavioral Cloning
Train a deep neural network to drive a car like you!
- Concept 01: Vehicle Simulator
- Concept 02: Intro to Behavioral Cloning Project
- Concept 03: Project Resources
- Concept 04: Running the Simulator
- Concept 05: Data Collection Tactics
- Concept 06: Data Collection Strategies
- Concept 07: Data Visualization
- Concept 08: Training Your Network
- Concept 09: Running Your Network
- Concept 10: Data Preprocessing
- Concept 11: More Networks
- Concept 12: Data Augmentation
- Concept 13: Using Multiple Cameras
- Concept 14: Cropping Images in Keras
- Concept 15: Even More Powerful Network
- Concept 16: More Data Collection
- Concept 17: Visualizing Loss
- Concept 18: Generators
- Concept 19: Recording Video in Autonomous Mode
- Concept 20: Project Workspace Instructions
- Concept 21: Project Behavioral Cloning
- Concept 22: Share your success - Behavioral Cloning
-
-
Module 04: GitHub Lesson
-
Lesson 01: GitHub
Build a GitHub Profile on par with senior software engineers.
- Concept 01: Introduction
- Concept 02: GitHub profile important items
- Concept 03: Good GitHub repository
- Concept 04: Interview with Art - Part 1
- Concept 05: Identify fixes for example “bad” profile
- Concept 06: Quick Fixes #1
- Concept 07: Quick Fixes #2
- Concept 08: Writing READMEs with Walter
- Concept 09: Interview with Art - Part 2
- Concept 10: Commit messages best practices
- Concept 11: Reflect on your commit messages
- Concept 12: Participating in open source projects
- Concept 13: Interview with Art - Part 3
- Concept 14: Participating in open source projects 2
- Concept 15: Starring interesting repositories
- Concept 16: Next Steps
-
-
Module 05: Sensor Fusion
-
Lesson 01: Sensors
Meet the team at Mercedes who will help you track objects in real-time with Sensor Fusion.
-
Lesson 02: Kalman Filters
Sebastian Thrun will walk you through the usage and concepts of a Kalman Filter using Python.
- Concept 01: Introduction
- Concept 02: Tracking Intro
- Concept 03: Gaussian Intro
- Concept 04: Variance Comparison
- Concept 05: Preferred Gaussian
- Concept 06: Evaluate Gaussian
- Concept 07: Maximize Gaussian
- Concept 08: Measurement and Motion
- Concept 09: Shifting the Mean
- Concept 10: Predicting the Peak
- Concept 11: Parameter Update
- Concept 12: Parameter Update 2
- Concept 13: Separated Gaussians
- Concept 14: Separated Gaussians 2
- Concept 15: New Mean and Variance
- Concept 16: Gaussian Motion
- Concept 17: Predict Function
- Concept 18: Kalman Filter Code
- Concept 19: Kalman Prediction
- Concept 20: Kalman Filter Land
- Concept 21: Kalman Filter Prediciton
- Concept 22: Another Prediction
- Concept 23: More Kalman Filters
- Concept 24: Kalman Filter Design
- Concept 25: Kalman Matrices
- Concept 26: Conclusion
-
Lesson 03: C++ Checkpoint
Are you ready to build Kalman Filters with C++? Take these quizzes to find out!
- Concept 01: High Performance Computing
- Concept 02: [Optional] Beta Test our Upcoming C++ Course
- Concept 03: Challenge 1
- Concept 04: Challenge 1 Solution
- Concept 05: Challenge 2
- Concept 06: Challenge 2 Solution
- Concept 07: Challenge 3
- Concept 08: Challenge 3 Solution
- Concept 09: Challenge 4
- Concept 10: Challenge 4 Solution
- Concept 11: Challenge 5
- Concept 12: Challenge 5 Solution
- Concept 13: Outro and Advice
-
Lesson 04: Geometry and Trigonometry Refresher
This optional content is designed to refresh knowledge of trigonometry and geometry in support of Term 1 objectives.
- Concept 01: About this Lesson
- Concept 02: Lesson Introduction
- Concept 03: Plotting Robot Motion (right angles only)
- Concept 04: Plotting Robot Motion Solution
- Concept 05: Moving at an Angle
- Concept 06: Moving at 53.13 Degrees
- Concept 07: Who Cares About 53.13 Degrees?
- Concept 08: The Power of Trigonometry
- Concept 09: Opposite, Adjacent, Hypotenuse
- Concept 10: Trigonometric Ratios
- Concept 11: Looking up Sin, Cos, and Tan
- Concept 12: Trigonometry and Vehicle Motion
- Concept 13: Solving Trig Problems
- Concept 14: Keeping Track of x and y
- Concept 15: Keeping Track of x and y (solution)
- Concept 16: Conclusion
-
Lesson 05: Extended Kalman Filters
Build a Kalman Filter in C++ that's capable of handling data from multiple sources.
- Concept 01: Kalman Filters in C++
- Concept 02: Intro
- Concept 03: Lesson Map and Fusion Flow
- Concept 04: Lesson Variables and Equations
- Concept 05: Estimation Problem Refresh
- Concept 06: Kalman Filter Intuition
- Concept 07: Kalman Filter Equations in C++ Part 1
- Concept 08: Kalman Filter Equations in C++ Part 2
- Concept 09: State Prediction
- Concept 10: Process Covariance Matrix
- Concept 11: Laser Measurements Part 1
- Concept 12: Laser Measurements Part 2
- Concept 13: Laser Measurements Part 3
- Concept 14: Laser Measurements Part 4
- Concept 15: Radar Measurements
- Concept 16: Mapping with a Nonlinear Function
- Concept 17: Extended Kalman Filter
- Concept 18: Multivariate Taylor Series Expansion
- Concept 19: Jacobian Matrix Part 1
- Concept 20: Jacobian Matrix Part 2
- Concept 21: EKF Algorithm Generalization
- Concept 22: Sensor Fusion General Flow
- Concept 23: Evaluating KF Performance Part 1
- Concept 24: Evaluating KF Performance 2
- Concept 25: Outro
- Concept 26: Bonus Round: Sensor Fusion [Optional]
-
Lesson 06: Extended Kalman Filters Project
Apply everything you've learned about Sensor Fusion by implementing an Extended Kalman Filter in C++!
- Concept 01: Back to Bayes Theorem
- Concept 02: Intro to Extended Kalman Filter Project
- Concept 03: Data File for EKF project
- Concept 04: File Structure
- Concept 05: Main.cpp
- Concept 06: Project Code
- Concept 07: Tips and Tricks
- Concept 08: Project Resources
- Concept 09: Project Instructions for workspaces
- Concept 10: Project Extended Kalman Filter GPU
- Concept 11: Project Instructions for local setup
- Concept 12: uWebSocketIO Starter Guide
- Concept 13: Environment Setup (Windows)
- Concept 14: Environment Setup (Linux)
- Concept 15: Environment Setup (Mac)
- Concept 16: Compiling and Running the Project
- Concept 17: Share your success - EKF
-
Part 02 : Localization, Path Planning, Control, and System Integration
In this term, you'll expand on your sensor knowledge to localize and control the vehicle. You'll evaluate sensor data from camera, radar, lidar, and GPS, and use these in closed-loop controllers that actuate the vehicle.
After that, you'll learn how to plan where the vehicle should go, and how the vehicle systems work together to get it there.
-
Module 01: Introduction to Term 2
-
Lesson 01: Welcome
Congratulations once more on completing term 1! Your diligent studying and newly honed skills have brought you one major step closer to graduating the program - welcome to Term 2!
-
-
Module 02: Localization
-
Lesson 01: Introduction to Localization
Meet the team that will guide you through the localization lessons!
- Concept 01: Localization Overview
- Concept 02: Lesson Introduction
- Concept 03: Localization Intuition Quiz
- Concept 04: Localization Intuition Explanation
- Concept 05: Localizing a Self Driving Car
- Concept 06: Overview of the Lessons
- Concept 07: Localization
- Concept 08: Uniform Probability Quiz
- Concept 09: Uniform Distribution
- Concept 10: Generalized Uniform Distribution
- Concept 11: Probability After Sense
- Concept 12: Compute Sum
- Concept 13: Normalize Distribution
- Concept 14: pHit and pMiss
- Concept 15: Sum of Probabilities
- Concept 16: Sense Function
- Concept 17: Normalized Sense Function
- Concept 18: Test Sense Function
- Concept 19: Multiple Measurements
- Concept 20: Lesson Breakpoint
- Concept 21: Exact Motion
- Concept 22: Move Function
- Concept 23: Inexact Motion 1
- Concept 24: Inexact Motion 2
- Concept 25: Inexact Motion 3
- Concept 26: Inexact Move Function
- Concept 27: Limit Distribution Quiz
- Concept 28: Move Twice
- Concept 29: Move 1000
- Concept 30: Sense and Move
- Concept 31: Sense and Move 2
- Concept 32: Localization Summary
- Concept 33: Formal Definition of Probability 1
- Concept 34: Formal Definition of Probability 2
- Concept 35: Formal Definition of Probability 3
- Concept 36: Bayes' Rule
- Concept 37: Cancer Test
- Concept 38: Theorem of Total Probability
- Concept 39: Coin Flip Quiz
- Concept 40: Two Coin Quiz
-
Lesson 02: Markov Localization
Learn the math behind localization as well as how to implement Markov localization in C++.
- Concept 01: Return to Bayes' Rule
- Concept 02: Overview
- Concept 03: Localization Posterior: Introduction
- Concept 04: Localization Posterior Explanation and Implementation
- Concept 05: Bayes' Rule
- Concept 06: Bayes' Filter For Localization
- Concept 07: Calculate Localization Posterior
- Concept 08: Initialize Belief State
- Concept 09: Initialize Priors Function
- Concept 10: Solution: Initialize Priors Function
- Concept 11: Quiz: How Much Data?
- Concept 12: How Much Data: Explanation
- Concept 13: Derivation Outline
- Concept 14: Apply Bayes Rule with Additional Conditions
- Concept 15: Bayes Rule and Law of Total Probability
- Concept 16: Total Probability and Markov Assumption
- Concept 17: Markov Assumption for Motion Model: Quiz
- Concept 18: Markov Assumption for Motion Model: Explanation
- Concept 19: After Applying Markov Assumption: Quiz
- Concept 20: Recursive Structure
- Concept 21: Lesson Breakpoint
- Concept 22: Implementation Details for Motion Model
- Concept 23: Noise in Motion Model: Quiz
- Concept 24: Noise in Motion Model: Solution
- Concept 25: Determine Probabilities
- Concept 26: Motion Model Probabiity I
- Concept 27: Motion Model Probability II
- Concept 28: Coding the Motion Model
- Concept 29: Solution: Coding the Motion Model
- Concept 30: Observation Model Introduction
- Concept 31: Markov Assumption for Observation Model
- Concept 32: Finalize the Bayes Localization Filter
- Concept 33: Bayes Filter Theory Summary
- Concept 34: Observation Model Probability
- Concept 35: Get Pseudo Ranges
- Concept 36: Solution: Get Pseudo Ranges
- Concept 37: Coding the Observation Model
- Concept 38: Solution: Coding the Observation Model
- Concept 39: Coding the Full Filter
- Concept 40: Solution: Coding the Full Filter
- Concept 41: Conclusion
-
Lesson 03: Motion Models
Learn about vehicle movement and motion models to predict where your car will be at a future time.
- Concept 01: Motion in Autonomy
- Concept 02: Lesson Introduction
- Concept 03: Motion Models: Bicycle Model
- Concept 04: Yaw Rate and Velocity
- Concept 05: Note on Frames of Reference
- Concept 06: Roll, Pitch and Yaw: Quiz
- Concept 07: Odometry
- Concept 08: Odometry Errors: Quiz
- Concept 09: Odometry Errors: Solution
- Concept 10: Conclusion
-
Lesson 04: Particle Filters
Sebastian will teach you what a particle filter is, as well as the theory and math behind the filter.
- Concept 01: Field Trip
- Concept 02: State Space
- Concept 03: Belief Modality
- Concept 04: Efficiency
- Concept 05: Exact or Approximate
- Concept 06: Particle Filters
- Concept 07: Using Robot Class
- Concept 08: Robot Class Details
- Concept 09: Moving Robot
- Concept 10: Add Noise
- Concept 11: Robot World
- Concept 12: Creating Particles
- Concept 13: Robot Particles
- Concept 14: Importance Weight
- Concept 15: Resampling
- Concept 16: Never Sampled 1
- Concept 17: Never Sampled 2
- Concept 18: Never Sampled 3
- Concept 19: New Particle
- Concept 20: Resampling Wheel
- Concept 21: Orientation 1
- Concept 22: Orientation 2
- Concept 23: Error
- Concept 24: You and Sebastian
- Concept 25: Filters
- Concept 26: 2012
-
Lesson 05: Implementation of a Particle Filter
Now that you know the theory, learn how to code a particle filter!
- Concept 01: Particle Filters in C++
- Concept 02: Introduction
- Concept 03: Pseudocode
- Concept 04: Initialization
- Concept 05: Program Gaussian Sampling: Code
- Concept 06: Program Gaussian Sampling: Code Solution
- Concept 07: Prediction Step
- Concept 08: Calculate Prediction Step: Quiz
- Concept 09: Calculate Prediction Step Quiz Explanation
- Concept 10: Data Association: Nearest Neighbor
- Concept 11: Nearest Neighbor Advantages and Disadvantages
- Concept 12: Update Step
- Concept 13: Calculating Error
- Concept 14: Transformations and Associations
- Concept 15: Converting Landmark Observations
- Concept 16: Quiz: Landmarks
- Concept 17: Landmarks Quiz Solution
- Concept 18: Quiz: Association
- Concept 19: Quiz: Particle Weights
- Concept 20: Particle Weights Solution
- Concept 21: Explanation of Project Code
- Concept 22: Bonus Round: Localization [Optional]
-
Lesson 06: Kidnapped Vehicle Project
In this project, you'll build a particle filter and combine it with a real map to localize a vehicle!
-
-
Module 03: Path Planning
-
Lesson 01: Search
Learn about discrete path planning and algorithms for solving the path planning problem.
- Concept 01: Motion Planning
- Concept 02: Introduction to Path Planning
- Concept 03: About this Lesson
- Concept 04: Motion Planning
- Concept 05: Compute Cost
- Concept 06: Compute Cost 2
- Concept 07: Optimal Path
- Concept 08: Optimal Path 2
- Concept 09: Maze
- Concept 10: Maze 2
- Concept 11: First Search Program
- Concept 12: Expansion Grid
- Concept 13: Print Path
- Concept 14: A*
- Concept 15: Implement A*
- Concept 16: A* in Action
- Concept 17: Dynamic Programming
- Concept 18: Computing Value
- Concept 19: Computing Value 2
- Concept 20: Value Program
- Concept 21: Optimum Policy
- Concept 22: Left Turn Policy
- Concept 23: Planning Conclusion
-
Lesson 02: Prediction
Use data from sensor fusion to generate predictions about the likely behavior of moving objects.
- Concept 01: Introduction and Overview
- Concept 02: I/O Recap
- Concept 03: Model-Based vs Data-Driven Approaches
- Concept 04: Which is Best?
- Concept 05: Data Driven Example - Trajectory Clustering
- Concept 06: Trajectory Clustering 2 - Online Prediction
- Concept 07: Thinking about Model Based Approaches
- Concept 08: Frenet Coordinates
- Concept 09: Process Models
- Concept 10: More on Process Models
- Concept 11: Multimodal Estimation
- Concept 12: Summary of Data Driven and Model Based Approaches
- Concept 13: Overview of Hybrid Approaches
- Concept 14: Intro to Naive Bayes
- Concept 15: Naive Bayes Quiz
- Concept 16: Implement Naive Bayes C++
- Concept 17: Implement Naive Bayes C++ (solution)
- Concept 18: Conclusion
-
Lesson 03: Behavior Planning
Learn how to think about high-level behavior planning in a self-driving car.
- Concept 01: Where To
- Concept 02: Lesson Outline
- Concept 03: Understanding Output
- Concept 04: The Behavior Problem
- Concept 05: Finite State Machines
- Concept 06: Formalizing Finite State Machines
- Concept 07: FSM Intuition
- Concept 08: States for Self Driving Cars
- Concept 09: The States We'll Use
- Concept 10: Inputs to Transition Functions
- Concept 11: Behavior Planning Pseudocode
- Concept 12: Create a Cost Function - Speed Penalty
- Concept 13: Example Cost Function - Lane Change Penalty
- Concept 14: Implement a Cost Function in C++
- Concept 15: Implement a Cost Function in C++ (solution)
- Concept 16: Implement a Second Cost Function in C++
- Concept 17: Implement a Second Cost Function in C++ (solution)
- Concept 18: Cost Function Design and Weight Tweaking
- Concept 19: Cost Function Matching
- Concept 20: Scheduling Compute Time
- Concept 21: Implement Behavior Planner in C++
- Concept 22: Implement Behavior Planner in C++ (solution)
- Concept 23: Conclusion
-
Lesson 04: Trajectory Generation
Use C++ and the Eigen linear algebra library to build candidate trajectories for the vehicle to follow.
- Concept 01: From Behavior to Trajectory
- Concept 02: Lesson Overview
- Concept 03: The Motion Planning Problem
- Concept 04: Properties of Motion Planning Algorithms
- Concept 05: Types of Motion Planning Algorithms
- Concept 06: A* Reminder
- Concept 07: A* Reminder Solution
- Concept 08: Hybrid A* Introduction
- Concept 09: Hybrid A* Tradeoffs
- Concept 10: Hybrid A* Tradeoffs Solution
- Concept 11: Hybrid A* in Practice
- Concept 12: Hybrid A* Heuristics
- Concept 13: Hybrid A* Pseudocode
- Concept 14: Implement Hybrid A* in C++
- Concept 15: Implement Hybrid A* in C++ (solution)
- Concept 16: Environment Classification
- Concept 17: Frenet Reminder
- Concept 18: The Need for Time
- Concept 19: s, d, and t
- Concept 20: Trajectory Matching
- Concept 21: Structured Trajectory Generation Overview
- Concept 22: Trajectories with Boundary Conditions
- Concept 23: Jerk Minimizing Trajectories
- Concept 24: Derivation Overview
- Concept 25: Derivation Details 2
- Concept 26: Polynomial Trajectory Generation
- Concept 27: Implement Quintic Polynomial Solver C++
- Concept 28: Implement Quintic Polynomial Solver Solution
- Concept 29: What should be checked?
- Concept 30: Implementing Feasibility
- Concept 31: Putting it All Together
- Concept 32: Polynomial Trajectory Reading (optional)
- Concept 33: Polynomial Trajectory Generation Playground
- Concept 34: Conclusion
- Concept 35: Bonus Round: Path Planning [Optional]
-
Lesson 05: Project: Highway Driving
Drive a car down a highway with other cars using your own path planner!
-
-
Module 04: Control
-
Lesson 01: PID Control
Learn about and how to use PID controllers with Sebastian!
- Concept 01: Intro
- Concept 02: PID Control
- Concept 03: Proportional Control
- Concept 04: Implement P Controller
- Concept 05: P Controller Solution
- Concept 06: Oscillations
- Concept 07: PD Controller
- Concept 08: PD Controller Solution
- Concept 09: Systematic Bias
- Concept 10: Is PD Enough
- Concept 11: PID implementation
- Concept 12: PID Implementation Solution
- Concept 13: Twiddle
- Concept 14: Parameter Optimization
- Concept 15: Parameter Optimization Solution
- Concept 16: Outro
- Concept 17: Bonus Round: Control [Optional]
-
Lesson 02: Project: PID Controller
Implement a PID controller in C++ to maneuver the vehicle around the lake race track!
-
-
Module 05: Career Services
-
Lesson 01: Take 30 Min to Improve your LinkedIn
Find your next job or connect with industry peers on LinkedIn. Ensure your profile attracts relevant leads that will grow your professional network.
- Concept 01: Get Opportunities with LinkedIn
- Concept 02: Use Your Story to Stand Out
- Concept 03: Why Use an Elevator Pitch
- Concept 04: Create Your Elevator Pitch
- Concept 05: Use Your Elevator Pitch on LinkedIn
- Concept 06: Create Your Profile With SEO In Mind
- Concept 07: Profile Essentials
- Concept 08: Work Experiences & Accomplishments
- Concept 09: Build and Strengthen Your Network
- Concept 10: Reaching Out on LinkedIn
- Concept 11: Boost Your Visibility
- Concept 12: Up Next
-
Lesson 02: Optimize Your GitHub Profile
Other professionals are collaborating on GitHub and growing their network. Submit your profile to ensure your profile is on par with leaders in your field.
- Concept 01: Prove Your Skills With GitHub
- Concept 02: Introduction
- Concept 03: GitHub profile important items
- Concept 04: Good GitHub repository
- Concept 05: Interview with Art - Part 1
- Concept 06: Identify fixes for example “bad” profile
- Concept 07: Quick Fixes #1
- Concept 08: Quick Fixes #2
- Concept 09: Writing READMEs with Walter
- Concept 10: Interview with Art - Part 2
- Concept 11: Commit messages best practices
- Concept 12: Reflect on your commit messages
- Concept 13: Participating in open source projects
- Concept 14: Interview with Art - Part 3
- Concept 15: Participating in open source projects 2
- Concept 16: Starring interesting repositories
- Concept 17: Next Steps
-
-
Module 06: System Integration
-
Lesson 01: Autonomous Vehicle Architecture
Learn about the system architecture for Carla, Udacity's autonomous vehicle!
- Concept 01: Putting Everything Together
- Concept 02: Introduction
- Concept 03: The Sensor Subsystem
- Concept 04: The Perception Subsystem
- Concept 05: Perception Subsystem Components
- Concept 06: The Planning Subsystem
- Concept 07: Planning Subsystem Components
- Concept 08: The Control Subsystem
- Concept 09: On to the code!
-
Lesson 02: Introduction to ROS
Obtain an architectural overview of the ROS Framework and setup your own ROS environment on your computer.
- Concept 01: Communications Between Systems
- Concept 02: Introduction
- Concept 03: Welcome to ROS Essentials
- Concept 04: Build Robots with ROS
- Concept 05: Brief History of ROS
- Concept 06: Nodes and Topics
- Concept 07: Message Passing
- Concept 08: Services
- Concept 09: Compute Graph
- Concept 10: Turtlesim Overview
- Concept 11: ROS Workspace Instructions
- Concept 12: ROS Workspace
- Concept 13: Your Virtual Machine
- Concept 14: Source the ROS Environment
- Concept 15: Run Turtlesim
- Concept 16: Turtlesim Comms: List Nodes
- Concept 17: Turtlesim Comms: List Topics
- Concept 18: Turtlesim Comms: Get Topic Info
- Concept 19: Turtlesim Comms: Message Information
- Concept 20: Turtlesim Comms: Echo a Topic
- Concept 21: Recap
-
Lesson 03: Packages & Catkin Workspaces
Learn about ROS workspace structure, essential command line utilities, and how to manage software packages within a project.
-
Lesson 04: Writing ROS Nodes
Learn to write ROS Nodes in Python.
- Concept 01: Closing In
- Concept 02: Overview
- Concept 03: ROS Publishers
- Concept 04: Simple Mover
- Concept 05: Simple Mover: The Code
- Concept 06: ROS Services
- Concept 07: Arm Mover
- Concept 08: Arm Mover: The Code
- Concept 09: Arm Mover: Launch and Interact
- Concept 10: ROS Subscribers
- Concept 11: Look Away
- Concept 12: Look Away: The Code
- Concept 13: Look Away: Launch and Interact
- Concept 14: Logging
- Concept 15: Recap
- Concept 16: Outro
-
Lesson 05: Project: Program an Autonomous Vehicle
Run your code on Carla, Udacity's own autonomous vehicle!
- Concept 01: Have Fun!
- Concept 02: Introduction
- Concept 03: Getting Started
- Concept 04: Project Overview
- Concept 05: Waypoint Updater Node (Partial)
- Concept 06: Waypoint Updater Partial Walkthrough
- Concept 07: DBW Node
- Concept 08: DBW Walkthrough
- Concept 09: Traffic Light Detection Node
- Concept 10: Object Detection Lab
- Concept 11: Detection Walkthrough
- Concept 12: Waypoint Updater Node (Full)
- Concept 13: Full Waypoint Walkthrough
- Concept 14: Project Submission and Getting Feedback
- Concept 15: Project Workspace Instructions
- Concept 16: Capstone Project Workspace
-
-
Module 07: Completing the Program
-
Lesson 01: Completing the Program
Congratulations! You've reached the end of the program! Learn how to officially complete the program and graduate.
-
Part 03 (Elective): Additional Content
Find additional optional content on Unscented Kalman Filters, Model Predictive Control, Advanced Deep Learning / Semantic Segmentation, and Functional Safety here.
-
Module 01: Vehicle Detection and Tracking
-
Lesson 01: Object Detection
In this lesson, you'll learn how to detect and track vehicles using color and gradient features and a support vector machine classifier.
- Concept 01: Intro to Vehicle Tracking
- Concept 02: Arpan and Drew
- Concept 03: Finding Cars
- Concept 04: Object Detection Overview
- Concept 05: Manual Vehicle Detection
- Concept 06: Features
- Concept 07: Feature Intuition
- Concept 08: Color Features
- Concept 09: Template Matching
- Concept 10: Template Matching Quiz
- Concept 11: Color Histogram Features
- Concept 12: Histograms of Color
- Concept 13: Histogram Comparison
- Concept 14: Color Spaces
- Concept 15: Explore Color Spaces
- Concept 16: Spatial Binning of Color
- Concept 17: Gradient Features
- Concept 18: HOG Features
- Concept 19: Data Exploration
- Concept 20: scikit-image HOG
- Concept 21: Combining Features
- Concept 22: Combine and Normalize Features
- Concept 23: Build a Classifier
- Concept 24: Labeled Data
- Concept 25: Data Preparation
- Concept 26: Train a Classifier
- Concept 27: Parameter Tuning
- Concept 28: Color Classify
- Concept 29: HOG Classify
- Concept 30: Sliding Windows
- Concept 31: How many windows?
- Concept 32: Sliding Window Implementation
- Concept 33: Multi-scale Windows
- Concept 34: Search and Classify
- Concept 35: Hog Sub-sampling Window Search
- Concept 36: False Positives
- Concept 37: Multiple Detections & False Positives
- Concept 38: Tracking Pipeline
- Concept 39: Summary
- Concept 40: Traditional vs. Deep Learning Approach
-
-
Module 02: Unscented Kalman Filters
-
Lesson 01: Unscented Kalman Filters
While Extended Kalman Filters work great for linear motion, real objects rarely move linearly. With Unscented Kalman Filters, you'll be able to accurately track non-linear motion!
- Concept 01: Introduction
- Concept 02: The CTRV Model
- Concept 03: The CTRV Model State Vector
- Concept 04: CTRV Differential Equation
- Concept 05: CTRV Integral 1
- Concept 06: CTRV Integral 2
- Concept 07: CTRV Zero Yaw Rate
- Concept 08: CTRV Process Noise Vector
- Concept 09: CTRV Process Noise Position
- Concept 10: UKF Process Chain
- Concept 11: What Problem Does the UKF Solve?
- Concept 12: UKF Basics Unscented Transformation
- Concept 13: Generating Sigma Points
- Concept 14: Generating Sigma Points Assignment 1
- Concept 15: Generating Sigma Points Assignment 2
- Concept 16: UKF Augmentation
- Concept 17: Augmentation Assignment 1
- Concept 18: Augmentation Assignment 2
- Concept 19: Sigma Point Prediction
- Concept 20: Sigma Point Prediction Assignment 1
- Concept 21: Sigma Point Prediction Assignment 2
- Concept 22: Predicted Mean and Covariance
- Concept 23: Predicted Mean and Covariance Assignment 1
- Concept 24: Predicted Mean and Covariance Assignment 2
- Concept 25: Measurement Prediction
- Concept 26: Predict Radar Measurement Assignment 1
- Concept 27: Predict Radar Measurement Assignment 2
- Concept 28: UKF Update
- Concept 29: UKF Update Assignment 1
- Concept 30: UKF Update Assignment 2
- Concept 31: Parameters and Consistency
- Concept 32: What to Expect from the Project
- Concept 33: Story Time
- Concept 34: Outro
- Concept 35: Bonus Round: Sensor Fusion [Optional]
-
-
Module 03: Model Predictive Control
-
Lesson 01: Vehicle Models
In this lesson, you'll learn about kinematic and dynamic vehicle models. We'll use these later with Model Predictive Control.
- Concept 01: Intro
- Concept 02: Vehicle Models
- Concept 03: State
- Concept 04: Building a Kinematic Model
- Concept 05: Global Kinematic Model
- Concept 06: Solution: Global Kinematic Model
- Concept 07: Following Trajectories
- Concept 08: Fitting Polynomials
- Concept 09: Solution: Fitting Polynomials
- Concept 10: Errors
- Concept 11: Dynamic Models
- Concept 12: Dynamic Models - Forces
- Concept 13: Dynamic Models - Slip Angle
- Concept 14: Dynamic Models - Slip Ratio
- Concept 15: Dynamic Models - Tire Models
- Concept 16: Actuator Constraints
- Concept 17: Outro
-
Lesson 02: Model Predictive Control
In this lesson, you'll learn how to frame the control problem as an optimization problem over time horizons. This is Model Predictive Control!
- Concept 01: Intro
- Concept 02: Reference State
- Concept 03: Dealing With Stopping
- Concept 04: Additional Cost Considerations
- Concept 05: Length and Duration
- Concept 06: Putting It All Together
- Concept 07: Latency
- Concept 08: Mind The Line
- Concept 09: Solution: Mind The Line
- Concept 10: Tuning MPC
- Concept 11: Outro
- Concept 12: Bonus Round: Control [Optional]
-
-
Module 04: Advanced Deep Learning
-
Lesson 01: Fully Convolutional Networks
In this lesson you'll learn the motivation for Fully Convolutional Networks and how they are structured.
- Concept 01: Intro
- Concept 02: Why Fully Convolutional Networks (FCNs) ?
- Concept 03: Fully Convolutional Networks
- Concept 04: Fully Connected to 1x1 Convolution
- Concept 05: 1x1 Convolution Quiz
- Concept 06: 1x1 Convolution Quiz Solution
- Concept 07: Transposed Convolutions
- Concept 08: Transposed Convolution Quiz
- Concept 09: Transposed Convolution Quiz Solution
- Concept 10: Skip Connections
- Concept 11: FCNs In The Wild
- Concept 12: Outro
-
Lesson 02: Scene Understanding
In this lesson you'll be introduced to the problem of Scene Understanding and the role FCNs play.
- Concept 01: Intro
- Concept 02: Bounding Boxes
- Concept 03: Semantic Segmentation
- Concept 04: Scene Understanding
- Concept 05: IoU
- Concept 06: IOU Example
- Concept 07: IoU Quiz
- Concept 08: IOU Solution
- Concept 09: FCN-8 - Encoder
- Concept 10: FCN-8 - Decoder
- Concept 11: FCN-8 - Classification & Loss
- Concept 12: Object Detection Lab
- Concept 13: Outro
-
Lesson 03: Inference Performance
In this lesson you'll become familiar with various optimizations in an effort to squeeze every last bit of performance at inference.
- Concept 01: Intro
- Concept 02: Why Bother With Performance
- Concept 03: Semantic Segmentation Revisited
- Concept 04: Interlude: Using The AMI
- Concept 05: Freezing Graphs
- Concept 06: Graph Transforms
- Concept 07: Fusion
- Concept 08: Optimizing For Inference
- Concept 09: Reducing Precision
- Concept 10: Quantization Quiz
- Concept 11: Quantization Conversion
- Concept 12: 8-bit Calculations
- Concept 13: Compilation
- Concept 14: AOT & JIT
- Concept 15: Reusing The Graph
- Concept 16: Outro
-
-
Module 05: Functional Safety
-
Lesson 01: Introduction to Functional Safety
You will learn to make safer vehicles using risk evaluation and systems engineering.
- Concept 01: Introduction to the Functional Safety Module
- Concept 02: Introduction to the Lesson
- Concept 03: What is Safety?
- Concept 04: What is Functional Safety?
- Concept 05: Introduction to Identifying Hazards
- Concept 06: Sebastian and Technology Errors
- Concept 07: Introduction to Evaluating Risks
- Concept 08: Reducing Risk with Systems Engineering
- Concept 09: Introduction to ISO 26262
- Concept 10: The Full V Model
- Concept 11: Summary
- Concept 12: Sebastian Talks About Self-Driving Car Risks
-
Lesson 02: Functional Safety: Safety Plan
A functional safety plan is critical to any functional safety project. Here you will learn what goes into a safety plan so that you can document your own.
-
Lesson 03: Functional Safety: Hazard Analysis and Risk Assessment
In a hazard analysis and risk assessment, you will identify vehicular malfunctions and evaluate their risk levels. You can then derive safety goals defining how your vehicle will remain safe.
- Concept 01: Introduction
- Concept 02: Advanced Driver Assistance System
- Concept 03: Item Definition
- Concept 04: Introduction to Hazard Analysis and Risk Assessment
- Concept 05: Sebastian Discussing Hazards
- Concept 06: Situational Analysis
- Concept 07: Identification of Hazards
- Concept 08: Risk Assessment, Severity, Exposure, Controllability
- Concept 09: Automotive Safety Integrity Levels (ASIL)
- Concept 10: Safety Goals
- Concept 11: Lesson Summary
-
Lesson 04: Functional Safety: Functional Safety Concept
You will derive functional safety requirements from the safety goals and then add extra functionality to the system diagram. Finally you document your work, a part of functional safety.
- Concept 01: Introduction
- Concept 02: Functional Safety Analysis
- Concept 03: Functional Safety Requirements
- Concept 04: Allocation to the Architecture
- Concept 05: Architecture Refinement
- Concept 06: ASIL Inheritance
- Concept 07: ASIL Decomposition
- Concept 08: Fault Tolerant Time Interval
- Concept 09: Warning and Degradation Concept
- Concept 10: Verification and Validation Acceptance Criteria
- Concept 11: Sebastian On Requirements and Testing
- Concept 12: Summary
-
Lesson 05: Functional Safety: Technical Safety Concept
Once you have derived functional safety requirements, you drill down into more detail. In the technical safety concept, you refine your requirements into technical safety requirements.
- Concept 01: Introduction
- Concept 02: Deriving Technical Safety Requirements
- Concept 03: Other Types of Technical Safety Requirements
- Concept 04: Technical Safety Requirement Attributes
- Concept 05: Allocation of Requirements to System Architecture Elements
- Concept 06: Sebastian on Testing
- Concept 07: Summary
-
Lesson 06: Functional Safety at the Software and Hardware Levels
The last step in the vehicle safety design phase is to derive hardware and software safety requirements. In this lesson, you will derive these requirements and refine a software system architecture.
- Concept 01: Introduction
- Concept 02: V model
- Concept 03: Hardware Failure Metrics
- Concept 04: Programming Languages
- Concept 05: Software Safety Life-cycle
- Concept 06: Software Safety Requirements Lane Departure Warning
- Concept 07: Other Sources of Software Safety Requirements
- Concept 08: Freedom from Interference - Spatial
- Concept 09: Freedom from Interference - Temporal
- Concept 10: Freedom from Interference - Temporal Part 2
- Concept 11: Sebastian and Temporal Interference
- Concept 12: Freedom from Interference - Communication
- Concept 13: System Architecture Safety Design Patterns
- Concept 14: Lesson Summary
- Concept 15: Module Summary
-
Part 04 (Elective): Autonomous Systems Interview
Start off with some tips on interviewing for an autonomous systems role, then watch how candidates approach their interview questions. Finish off by practicing some questions of your own!
-
Module 01: Autonomous Systems Interview
-
Lesson 01: Autonomous Systems Interview Practice
Start off with some tips on interviewing for an autonomous systems role, then watch how candidates approach their interview questions. Finish off by practicing some questions of your own!
Project Description - Autonomous Systems Interview Practice Project
Project Rubric - Autonomous Systems Interview Practice Project
- Concept 01: Welcome to the Course!
- Concept 02: Job Titles
- Concept 03: Your Part
- Concept 04: One Piece of the Puzzle
- Concept 05: Job Descriptions
- Concept 06: Research the Company
- Concept 07: Let's Get Started
- Concept 08: Perception Engineer
- Concept 09: Perception Engineer Reflection
- Concept 10: Deep Learning Engineer
- Concept 11: Deep Learning Engineer Reflection
- Concept 12: Motion Planning Engineer
- Concept 13: Motion Planning Engineer Reflection
- Concept 14: Mapping/Localization Engineer
- Concept 15: Mapping/Localization Engineer Reflection
- Concept 16: Control Engineer
- Concept 17: Control Engineer Reflection
- Concept 18: My Own Project
- Concept 19: My Own Project Reflection
- Concept 20: Additional Resources to Consider
- Concept 21: Final Thoughts
- Concept 22: Project Instructions
- Concept 23: Perception/Sensor Questions
- Concept 24: Deep Learning Questions
- Concept 25: Motion Planning Questions
- Concept 26: Mapping/Localization Questions
- Concept 27: Control Questions
- Concept 28: General Questions
-
Part 05 (Elective): Technical Interview Prep
Learn the skills technical interviewers expect you to know—efficiency, common algorithms, manipulating popular data structures, and how to explain a solution.
-
Module 01: Technical Interview Prep
-
Lesson 01: Introduction and Efficiency
Begin the section on data structures and algorithms, including Python and efficiency practice.
- Concept 01: Course Introduction
- Concept 02: Course Outline
- Concept 03: Course Expectations
- Concept 04: Syntax
- Concept 05: Python Practice
- Concept 06: Python: The Basics
- Concept 07: Efficiency
- Concept 08: Notation Intro
- Concept 09: Notation Continued
- Concept 10: Worst Case and Approximation
- Concept 11: Efficiency Practice
-
Lesson 02: List-Based Collections
Learn the definition of a list in computer science, and see definitions and examples of list-based data structures, arrays, linked lists, stacks, and queues.
- Concept 01: Welcome to Collections
- Concept 02: Lists
- Concept 03: Arrays
- Concept 04: Python Lists
- Concept 05: Linked Lists
- Concept 06: Linked Lists in Depth
- Concept 07: Linked List Practice
- Concept 08: Stacks
- Concept 09: Stacks Details
- Concept 10: Stack Practice
- Concept 11: Queues
- Concept 12: Queue Practice
-
Lesson 03: Searching and Sorting
Explore how to search and sort with list-based data structures, including binary search and bubble, merge, and quick sort. Learn how to use recursion.
- Concept 01: Binary Search
- Concept 02: Efficiency of Binary Search
- Concept 03: Binary Search Practice
- Concept 04: Recursion
- Concept 05: Recursion Practice
- Concept 06: Intro to Sorting
- Concept 07: Bubble Sort
- Concept 08: Efficiency of Bubble Sort
- Concept 09: Bubble Sort Practice
- Concept 10: Merge Sort
- Concept 11: Efficiency of Merge Sort
- Concept 12: Merge Sort Practice
- Concept 13: Quick Sort
- Concept 14: Efficiency of Quick Sort
- Concept 15: Quick Sort Practice
-
Lesson 04: Maps and Hashing
Understand the concepts of sets, maps (dictionaries), and hashing. Examine common problems and approaches to hashing, and practice with examples.
-
Lesson 05: Trees
Learn the concepts and terminology associated with tree data structures. Investigate tree types, such as binary search trees, heaps, and self-balancing trees.
- Concept 01: Trees
- Concept 02: Tree Basics
- Concept 03: Tree Terminology
- Concept 04: Tree Practice
- Concept 05: Tree Traversal
- Concept 06: Depth-First Traversals
- Concept 07: Tree Traversal Practice
- Concept 08: Search and Delete
- Concept 09: Insert
- Concept 10: Binary Search Trees
- Concept 11: Binary Tree Practice
- Concept 12: BSTs
- Concept 13: BST Complications
- Concept 14: BST Practice
- Concept 15: Heaps
- Concept 16: Heapify
- Concept 17: Heap Implementation
- Concept 18: Self-Balancing Trees
- Concept 19: Red-Black Trees - Insertion
- Concept 20: Tree Rotations
-
Lesson 06: Graphs
Examine the theoretical concept of a graph and understand common graph terms, coded representations, properties, traversals, and paths.
- Concept 01: Graph Introduction
- Concept 02: What Is a Graph?
- Concept 03: Directions and Cycles
- Concept 04: Connectivity
- Concept 05: Graph Practice
- Concept 06: Graph Representations
- Concept 07: Adjacency Matrices
- Concept 08: Graph Representation Practice
- Concept 09: Graph Traversal
- Concept 10: DFS
- Concept 11: BFS
- Concept 12: Graph Traversal Practice
- Concept 13: Eulerian Path
-
Lesson 07: Case Studies in Algorithms
Explore famous computer science problems, specifically the Shortest Path Problem, the Knapsack Problem, and the Traveling Salesman Problem.
-
Lesson 08: Technical Interviewing Techniques
Learn about the “algorithm” for answering common technical interviewing questions. Practice and get tips for giving interviewers what they’re looking for.
- Concept 01: Interview Introduction
- Concept 02: Clarifying the Question
- Concept 03: Confirming Inputs
- Concept 04: Test Cases
- Concept 05: Brainstorming
- Concept 06: Runtime Analysis
- Concept 07: Coding
- Concept 08: Debugging
- Concept 09: Interview Wrap-Up
- Concept 10: Time for Live Practice with Pramp
- Concept 11: Next Steps
-
-
Module 02: Behavioral Questions
-
Lesson 01: Practice Behavioral Questions
Practice answering behavioral questions and evaluate sample responses.
- Concept 01: Introduction
- Concept 02: Self-Practice: Behavioral Questions
- Concept 03: Analyzing Behavioral Answers
- Concept 04: Time When You Showed Initiative?
- Concept 05: What Motivates You at the Workplace?
- Concept 06: A Problem and How You Dealt With It?
- Concept 07: What Do You Know About the Company?
- Concept 08: Time When You Dealt With Failure?
-
Lesson 02: Land a Job Offer
You've practiced a lot for the interview by now. Continue practicing, and you'll ace the interview!
-